import express from "express";
import User from "./model.js";
import jwt from "jsonwebtoken";
import auth from "../token/auth.js";
const JWT_SECRET = "qweasdzxc123456789";
const router = express.Router();

// 注册接口
router.post("/register", auth, async (req, res) => {
  const { account, password, name, position, creatorId } = req.body;
  if (!account || !password || !name || !position || !creatorId) {
    return res.status(400).json({ error: "缺少必要字段" });
  }
  // 查询添加者身份
  const creator = await User.findById(creatorId);
  if (!creator || !["社长", "管理员"].includes(creator.position)) {
    return res.status(403).json({ error: "只有社长或管理员可以添加账号" });
  }
  // 职位权限判断
  if (position === "社长") {
    return res.status(403).json({ error: "社长职位不可注册" });
  }
  if (creator.position === "社长") {
    if (!["管理员", "社员"].includes(position)) {
      return res.status(400).json({ error: "社长只能注册管理员或社员账号" });
    }
  } else if (creator.position === "管理员") {
    if (position !== "社员") {
      return res.status(400).json({ error: "管理员只能注册社员账号" });
    }
  }
  try {
    const exist = await User.findOne({ account });
    if (exist) {
      return res.status(409).json({ error: "账号已存在" });
    }
    const user = new User({ account, password, name, position });
    await user.save();
    res.json({ message: "注册成功" });
  } catch (err) {
    res.status(500).json({ error: "注册失败" });
  }
});

// 登录接口
router.post("/login", async (req, res) => {
  const { account, password } = req.body;
  if (!account || !password) {
    return res.status(400).json({ error: "缺少账号或密码" });
  }
  try {
    const user = await User.findOne({ account, password });
    if (!user) {
      return res.status(401).json({ error: "账号或密码错误" });
    }
    // 生成token
    const token = jwt.sign(
      { _id: user._id, position: user.position },
      JWT_SECRET,
      { expiresIn: "3h" }
    );
    res.json({
      message: "登录成功",
      token,
      user: {
        _id: user._id,
        account: user.account,
        name: user.name,
        position: user.position,
      },
    });
  } catch (err) {
    res.status(500).json({ error: "登录失败" });
  }
});

// 获取所有用户
router.get("/", auth, async (req, res) => {
  const { requesterId } = req.query;
  if (!requesterId) {
    return res.status(400).json({ error: "缺少查询者id" });
  }
  // 查询请求者身份
  const requester = await User.findById(requesterId);
  if (!requester) {
    return res.status(404).json({ error: "查询者不存在" });
  }
  try {
    let users;
    if (requester.position === "社长") {
      users = await User.find({}, "-password"); // 社长获取所有用户
    } else if (requester.position === "管理员") {
      users = await User.find({ position: "社员" }, "-password"); // 管理员只能获取社员
    } else {
      return res.status(403).json({ error: "没有权限获取用户列表" });
    }
    res.json(users);
  } catch (err) {
    res.status(500).json({ error: "获取用户列表失败" });
  }
});

// 获取单个用户
router.get("/:id", auth, async (req, res) => {
  try {
    const user = await User.findById(req.params.id, "-password");
    if (!user) {
      return res.status(404).json({ error: "用户不存在" });
    }
    res.json(user);
  } catch (err) {
    res.status(500).json({ error: "获取用户失败" });
  }
});

// 更新用户
router.put("/:id", auth, async (req, res) => {
  const { name, position, password, updaterId } = req.body;
  if (!updaterId) {
    return res.status(400).json({ error: "缺少更新者id" });
  }
  // 查询更新者身份
  const updater = await User.findById(updaterId);
  if (!updater || !["社长", "管理员"].includes(updater.position)) {
    return res.status(403).json({ error: "只有社长或管理员可以修改账号" });
  }

  // 查询被更新用户
  const targetUser = await User.findById(req.params.id);
  if (!targetUser) {
    return res.status(404).json({ error: "用户不存在" });
  }
  // 被更新用户职位判断
  if (targetUser.position === "社长") {
    return res.status(403).json({ error: "社长职位不可被修改" });
  }
  if (targetUser.position === "管理员" && updater.position !== "社长") {
    return res.status(403).json({ error: "只有社长可以修改管理员账号" });
  }
  if (
    targetUser.position === "社员" &&
    !["社长", "管理员"].includes(updater.position)
  ) {
    return res.status(403).json({ error: "只有社长或管理员可以修改社员账号" });
  }

  // 新职位权限判断
  if (position) {
    if (position === "社长") {
      return res.status(403).json({ error: "社长职位不可被修改为" });
    }
    if (updater.position === "社长") {
      if (!["管理员", "社员"].includes(position)) {
        return res
          .status(400)
          .json({ error: "社长只能将职位修改为：管理员、社员" });
      }
    } else if (updater.position === "管理员") {
      if (position !== "社员") {
        return res.status(400).json({ error: "管理员只能将职位修改为：社员" });
      }
    }
  }

  try {
    const updateData = {};
    if (name) updateData.name = name;
    if (position) updateData.position = position;
    if (password) updateData.password = password;
    const user = await User.findByIdAndUpdate(req.params.id, updateData, {
      new: true,
      fields: { password: 0 },
    });
    if (!user) {
      return res.status(404).json({ error: "用户不存在" });
    }
    res.json({ message: "更新成功", user });
  } catch (err) {
    res.status(500).json({ error: "更新失败" });
  }
});

// 删除用户
router.delete("/:id", auth, async (req, res) => {
  const { deleterId } = req.query;
  if (!deleterId) {
    return res.status(400).json({ error: "缺少删除者id" });
  }
  // 查询删除者身份
  const deleter = await User.findById(deleterId);
  if (!deleter || !["社长", "管理员"].includes(deleter.position)) {
    return res.status(403).json({ error: "只有社长或管理员可以删除账号" });
  }
  // 查询被删除用户
  const user = await User.findById(req.params.id);
  if (!user) {
    return res.status(404).json({ error: "用户不存在" });
  }
  // 职位权限判断
  if (user.position === "社长") {
    return res.status(403).json({ error: "社长职位不可被删除" });
  }
  if (deleter.position === "社长") {
    if (!["管理员", "社员"].includes(user.position)) {
      return res.status(400).json({ error: "社长只能删除管理员或社员账号" });
    }
  } else if (deleter.position === "管理员") {
    if (user.position !== "社员") {
      return res.status(400).json({ error: "管理员只能删除社员账号" });
    }
  }
  try {
    await User.findByIdAndDelete(req.params.id);
    res.json({ message: "删除成功" });
  } catch (err) {
    res.status(500).json({ error: "删除失败" });
  }
});

// 用户个人编辑接口（仅允许本人修改自己的名称和密码，且需验证原密码）
router.put("/edit/:id", auth, async (req, res) => {
  const { name, oldPassword, newPassword } = req.body;
  const userId = req.params.id;

  // 只允许本人操作
  if (req.user._id !== userId) {
    return res.status(403).json({ error: "只能修改自己的信息" });
  }

  try {
    const user = await User.findById(userId);
    if (!user) {
      return res.status(404).json({ error: "用户不存在" });
    }
    // 校验原密码
    if (user.password !== oldPassword) {
      return res.status(401).json({ error: "原密码错误" });
    } else {
      // 构建更新内容
      const updateData = {};
      if (name) updateData.name = name;
      if (newPassword) updateData.password = newPassword;

      const updatedUser = await User.findByIdAndUpdate(userId, updateData, {
        new: true,
        fields: { password: 0 },
      });
      res.json({ message: "编辑成功", user: updatedUser });
    }
  } catch (err) {
    res.status(500).json({ error: "编辑失败" });
  }
});

export default router;
